# -*- coding: utf-8 -*-
"""
主面板模块：应用程序的主窗口，负责管理所有UI组件、数据交互和用户操作
"""
from datetime import datetime
import os
import time
import json
from PySide6.QtWidgets import (
    QApplication,
    QMainWindow,
    QDialog,
)
from PySide6.QtCore import (
    Qt,
    Signal,
    QTimer,
    QSettings,
    QThreadPool,
)

# 内部模块导入
from gui.schemas.configs import configs
from gui.ui.UI_main_window import Ui_MainWindow
from gui.utils.annotation_manager import CommandType, DataManager, ResponseStatus
from gui.utils.log import logger
from gui.utils.api import API, API_Interface_Schemas
from gui.window.annotator.job_tab_widget import Job_Tab_Annotator
from gui.window.child_dialog.datasets_manager import TableWidget_Datasets_manager
from gui.window.child_dialog.model import ModelManagerDialog
from gui.window.child_dialog.projects_manager import TableWidget_Projects_manager
from gui.window.child_dialog.tasks_manager import TableWidget_Tasks_manager
from gui.window.child_dialog.login_child_window import Login_Synchronous_Panel
from gui.window.child_dialog.add_job_child_window import Add_Job_Panel

# 常量定义：检测类型和文件类型选项
DETECTION_TYPES = ["矩形", "四边形", "多边形", "ocr", "分类"]
FILE_TYPES = ["图片", "视频"]


class Main_Panel(Ui_MainWindow, QMainWindow):
    """
    主面板类：继承自UI设计类和QMainWindow，是应用程序的主窗口
    负责协调所有子组件、数据加载和用户交互逻辑
    """

    # 进度条更新信号
    upgrade_progressBar_update_signal = Signal(int)

    def __init__(self, parent=None):
        """初始化主面板"""
        super(Main_Panel, self).__init__(parent)

        # 1. 初始化UI和基础设置
        self.setupUi(self)
        self.setWindowTitle("media_annotator")  # 设置窗口标题

        # 2. 初始化核心组件
        self._init_core_components()

        # 3. 初始化信号与槽连接
        self._init_connections()

        # 4. 初始化子窗口
        self._init_child_windows()

        # 5. 检查登录状态并初始化界面
        self._check_login_status()

    def _init_core_components(self):
        """初始化核心组件：配置、线程池、API客户端、数据管理器等"""
        # 应用设置缓存
        self.settings = QSettings(configs.APP_NAME, "media_annotator")

        # 线程池管理（使用CPU核心数作为最大线程数）
        self.thread_pool = QThreadPool.globalInstance()
        self.thread_pool.setMaxThreadCount(os.cpu_count())

        # API客户端初始化
        base_url = f"http://{configs.SERVICE_HOST}:{configs.SERVICE_PORT}"
        self.api_client = API(base_url)
        self.api_client.request_result.connect(self.api_success_response)

        # 加载用户信息
        userinfo = self.settings.value("userinfo", {})
        self.api_client.set_userinfo(**userinfo)

        # Redis数据管理器初始化
        redis_kwargs = {
            "redis_host": configs.SERVICE_HOST,
            "redis_port": configs.REDIS_PORT,
            "redis_password": configs.REDIS_PASSWORD,
            "redis_db": configs.REDIS_DB,
        }
        self.data_manager = DataManager(main_panel=self,**redis_kwargs)
        


        self.redis_connection_available = False  # Redis连接状态标记

        # 连接数据管理器信号
        self.data_manager.signals.connected.connect(self.on_redis_connected)
        self.data_manager.signals.command_result.connect(self.on_command_result)
        self.data_manager.signals.error_occurred.connect(self.on_error)
        self.data_manager.set_userinfo(**userinfo)

        # 启动数据管理器线程
        self.thread_pool.start(self.data_manager)

        # 初始化定时任务：定期获取当前标签页的文件数据
        self.timer_current_tab_get_files = QTimer()
        # self.timer_current_tab_get_files.setInterval(5000)  # 5秒间隔
        # self.timer_current_tab_get_files.timeout.connect(self._current_tab_get_files)
        # self.pushButton_synchronous.clicked.connect(self._current_tab_get_files)

    def _init_connections(self):
        """初始化UI组件的信号与槽连接"""
        # 按钮点击事件
        self.pushButton_login_synchronous_menu.clicked.connect(
            lambda: self.open_child_dialog_window(self.Login_Synchronous_Panel)
        )
        # 菜单动作事件
        self.action_datasets_manager.triggered.connect(
            lambda: self.open_child_dialog_window(self.datasets_manager_panel)
        )
        self.action_projects_manager.triggered.connect(
            lambda: self.open_child_dialog_window(self.projects_manager_panel)
        )
        self.action_task_manager.triggered.connect(
            lambda: self.open_child_dialog_window(self.tasks_manager_panel)
        )

    def _init_child_windows(self):
        """初始化子窗口实例"""
        self.datasets_manager_panel = TableWidget_Datasets_manager(self.api_client)
        self.projects_manager_panel = TableWidget_Projects_manager(self.api_client)
        self.tasks_manager_panel = TableWidget_Tasks_manager(self.api_client)
        self.Login_Synchronous_Panel = Login_Synchronous_Panel(self)
        self.add_job_Panel = Add_Job_Panel(self)

    def _check_login_status(self):
        """检查用户登录状态并更新界面"""
        self.api_client.check_login_status()

    def _current_tab_get_files(self):
        """定时任务：获取当前标签页的文件数据"""
        current_tab = self.tabWidget_anno.currentWidget()
        if isinstance(current_tab, Job_Tab_Annotator):
            current_tab.get_files_data()

    def on_command_result(self, cmd_type, result, status):
        """
        数据管理器命令执行结果回调

        Args:
            cmd_type: 命令类型
            result: 命令执行结果
            status: 执行状态（成功/失败）
        """
        if status == ResponseStatus.SUCCESS:
            if cmd_type == CommandType.GET_JOBS:
                # 处理工作列表数据
                self.process_jobs(result.get("jobs", {}))
        elif status == ResponseStatus.FAILURE:
            error_msg = result.get("error", "未知错误")
            logger.error(f"命令执行失败: {cmd_type}, 错误: {error_msg}")
            self.statusBar().showMessage(f"命令执行失败: {error_msg}")

    def process_jobs(self, jobs):
        """
        处理获取到的工作列表数据并刷新标签页

        Args:
            jobs: 工作列表数据
        """
        self.refresh_tabs(jobs)

    def manage_models(self):
        """打开模型管理对话框"""
        dialog = ModelManagerDialog(self.data_manager, self)
        dialog.exec()

    def open_child_dialog_window(self, child_dialog:QDialog):
        """打开子窗口（模态）"""
        child_dialog.setWindowModality(Qt.ApplicationModal)
        child_dialog.show()

    def closeEvent(self, event):
        """窗口关闭事件处理：停止数据管理器"""
        self.data_manager.stop()
        super().closeEvent(event)

    def on_redis_connected(self, success):
        """
        Redis连接状态回调

        Args:
            success: 连接是否成功
        """
        if success:
            self.statusBar().showMessage("已连接到Redis服务器")
            self.timer_current_tab_get_files.start()
            self.redis_connection_available = True
        else:
            self.statusBar().showMessage("连接Redis失败 - 仅使用本地模式")
            self.timer_current_tab_get_files.stop()
            self.redis_connection_available = False

    def refresh_tabs(self, tabs):
        """
        刷新标签页列表

        Args:
            tabs: 标签页数据字典
        """
        self.tabWidget_anno.clear()  # 清空现有标签页

        for tab_id, tab_info in tabs.items():
            tab_name = tab_info["name"]
            # 创建标签页组件
            tab_widget = Job_Tab_Annotator(self, tab_info)
            self.tabWidget_anno.addTab(tab_widget, tab_name)
            tab_widget.index = self.tabWidget_anno.indexOf(tab_widget)  # 记录标签页索引

        # 如果有标签页，默认选中第一个并加载数据
        if tabs:
            self.tabWidget_anno.setCurrentIndex(0)
            # 短暂延迟确保UI已更新
            QApplication.processEvents()
            current_tab = self.tabWidget_anno.currentWidget()
            if isinstance(current_tab, Job_Tab_Annotator):
                current_tab.get_files_data()

    def on_connection_checked(self, connected):
        """
        连接状态检查回调

        Args:
            connected: 是否连接
        """
        if connected:
            self.label_redis_status.setText("(已连接Redis)")
        else:
            self.label_redis_status.setText("(未连接Redis，更改将只保存到本地)")

    def on_error(self, error_msg):
        """
        错误处理回调

        Args:
            error_msg: 错误信息
        """
        logger.error(f"错误: {error_msg}")
        self.statusBar().showMessage(f"错误: {error_msg}")

    # region API请求响应处理
    def api_success_response(self, request_type, data, is_result):
        """
        API请求成功响应处理

        Args:
            request_type: 请求类型
            data: 响应数据
            is_result: 是否成功
        """
        if is_result:
            if request_type in API_Interface_Schemas.LOGIN[0]:
                self.login_success_response(data)
            self.statusBar().showMessage(f"{request_type} 请求成功")
        else:
            error_msg = data.get("error", "未知错误")
            self.statusBar().showMessage(f"{request_type} 请求失败: {error_msg}")

    def login_success_response(self, data):
        """
        登录成功响应处理

        Args:
            data: 登录用户信息
        """
        self.settings.setValue("userinfo", data)
        self.userinfo = data

        # 处理用户角色信息
        roles = data.get("roles", [])
        self.userinfo["role"] = roles[0] if roles else "普通用户"
        # 更新数据管理器的用户信息
        user_id = self.userinfo.get("id")
        user_name = self.userinfo.get("name")
        role = self.userinfo.get("role")
        self.data_manager.set_userinfo(user_id,user_name, role)

        # 更新UI状态
        self.Login_Synchronous_Panel.close()
        self.label_userinfo.setText(f"{data['username']} 连接正常")

        # 登录成功后获取工作列表
        self.data_manager.enqueue_command(CommandType.GET_JOBS, callback="jobs_fetched")

    def login_failure_response(self, data):
        """
        登录失败响应处理

        Args:
            data: 失败信息
        """
        self.Login_Synchronous_Panel.close()
        self.statusBar().showMessage(data)

    # endregion
